/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package Negocio;

/**
 *
 * @author Gustavo
 */
import java.util.LinkedList;
import java.util.StringTokenizer;

import Datos.Cliente;
import Datos.DetalleVenta;
import Datos.Producto;

import Datos.Archivo;

public class GestionDatos
{

    private LinkedList<Cliente> listaClientes;
    private LinkedList<Producto> listaProductos;
    private LinkedList<DetalleVenta> listaDetalle_Ventas;

    private String texto;
    private StringTokenizer st;

    public GestionDatos()
    {
        listaClientes = listarClientes();
        listaProductos = listarProductos();
        listaDetalle_Ventas = listarDetalleVentas();
    }


    private LinkedList<Cliente> listarClientes()
    {

        texto = Archivo.leer("./datos/Clientes.txt");

        st = new StringTokenizer(texto, ":\n");
        LinkedList<Cliente> lista = new LinkedList<Cliente>();

        try
        {
            while (st.hasMoreTokens())
            {
                Cliente cl = new Cliente();
                cl.setCodigo(Integer.parseInt(st.nextToken()));
                cl.setNombre(st.nextToken());
                cl.setMail(st.nextToken());
                cl.setTelefono(st.nextToken());
                cl.setCategoria(st.nextToken());
                lista.add(cl);
          
            }
        } 
        catch (Exception e)
        {
            e.printStackTrace();
        }
        return lista;
    }

    public LinkedList<Cliente> getListaClientes()
    {
        return listaClientes;
    }

    public void guardarClientes()
    {
        texto = "";

        for (Cliente cl: listaClientes)
        {
            texto += cl.toString() + "\n";
        }
        Archivo.escribir("./datos/Clientes.txt", texto);
    }

    public Cliente existeCliente(int id)
    {
        for (Cliente cl: listaClientes)
        {
            if (cl.getCodigo() == id)
                return cl;
        }
        return null;
    }

    public boolean existeMail(String mail)
    {
        for (Cliente cl: listaClientes)
        {
            if (cl.getMail().equalsIgnoreCase(mail))
                return true;
        }
        return false;
    }

    public String getMail(int id)
    {
        for (Cliente cl: listaClientes)
        {
            if (cl.getCodigo() == id)
                return cl.getMail();
        }
        return "";
    }

    public int getCodCliente(String mail)
    {
        for (Cliente cl: listaClientes)
        {
            if (cl.getMail().equals(mail))
                return cl.getCodigo();
        }
        return -1;
    }

    public int getCantidadClientes()
    {
        return listaClientes.size();
    }

    public int getLastIDCliente()
    {
        return listaClientes.getLast().getCodigo();
    }

    public void adicionarCliente(Cliente cliente)
    {
        if (!existeMail(cliente.getMail()))
        {
            listaClientes.add(cliente);
            guardarClientes();
            System.out.println("Se adiciono al cliente -> " + cliente.getMail());
        }
    }

    public void actualizarCliente(Cliente cliente)
    {
        LinkedList<Cliente> aux = new LinkedList<Cliente>();

        if (existeCliente(cliente.getCodigo())!=null)
        {
            for(Cliente cl:listaClientes)
            {
                if (cl.getCodigo() == cliente.getCodigo())
                    aux.add(cliente);
                else
                    aux.add(cl);
            }
            listaClientes = aux;
            guardarClientes();
            System.out.println("Se actualizo al cliente -> " + cliente.getMail());
        }
    }

    public void eliminarCliente(Cliente cliente)
    {

        if (listaClientes.remove(cliente))
        {
            guardarClientes();
            System.out.println("Se elimino el cliente -> " +cliente.getMail());
        }

    }

    public void eliminarCliente(int id)
    {
        Cliente cliente = null;
        cliente = existeCliente(id);

        if (cliente!=null)
        {
            eliminarCliente(cliente);
        }
    }

/*---------------------------------------------------------------------------*/

    private LinkedList<Producto> listarProductos()
    {

        texto = Archivo.leer("./datos/Productos.txt");
        st = new StringTokenizer(texto, ":\n");

        LinkedList<Producto> lista = new LinkedList<Producto>();

        try
        {
            while (st.hasMoreTokens())
            {
                Producto pr = new Producto();
                pr.setCodigo(Integer.parseInt(st.nextToken()));
                pr.setNombre(st.nextToken());
                pr.setDescripcion(st.nextToken());
                pr.setPrecio(Integer.parseInt(st.nextToken()));
                pr.setStock(Integer.parseInt(st.nextToken()));
                texto = st.nextToken();

                if (texto.equalsIgnoreCase("si"))
                    pr.setOferta(true);
                else
                    pr.setOferta(false);

                lista.add(pr);
            }
        } catch (Exception e)
        {
            e.printStackTrace();
        }
        return lista;
    }

    public LinkedList<Producto> getListaProductos()
    {
        return listaProductos;
    }

    public void guardarProductos()
    {
        texto = "";
        for (Producto pr: listaProductos)
        {
            texto += pr.toString() + "\n";
        }
        Archivo.escribir("./datos/Productos.txt", texto);
    }

    public Producto existeProducto(int id)
    {
        for (Producto pr: listaProductos)
        {
            if (pr.getCodigo() == id)
                return pr;
        }
        return null;
    }

    public boolean enOferta(int id)
    {
        for (Producto pr: listaProductos)
        {
            if (pr.getCodigo()==id)
                return pr.getOferta();
        }
        return false;
    }

    public void ofertarProducto(int id,int rebaja)
    {

        int precio=0;

        for (Producto pr: listaProductos)
        {
            if (pr.getCodigo()==id)
            {
               pr.setOferta(true);
               precio=pr.getPrecio();
               pr.setPrecio(precio-rebaja); 
               actualizarProducto(pr);
            }
        }

    }

    public String getDescripcion(int id)
    {
        for (Producto pr: listaProductos)
        {
            if (pr.getCodigo() == id)
                return pr.getDescripcion();
        }
        return "";
    }

    public int getCantidadProductos()
    {
        return listaProductos.size();
    }

    public int getLastIDProducto()
    {
        return listaClientes.getLast().getCodigo();
    }

    public void adicionarProducto(Producto producto)
    {
        if (existeProducto(producto.getCodigo())== null)
        {
            listaProductos.add(producto);
            guardarProductos();
            System.out.println("Se adiciono el producto -> " + producto.getCodigo());
        }
    }

    public void actualizarProducto(Producto producto)
    {
        LinkedList<Producto> aux = new LinkedList<Producto>();

        if (existeProducto(producto.getCodigo())!=null)
        {
            for(Producto pr: listaProductos)
            {
                if (pr.getCodigo() == producto.getCodigo())
                    aux.add(producto);
                else
                    aux.add(pr);
            }
            listaProductos = aux;
            guardarProductos();
            System.out.println("Se actualizo el producto -> " + producto.getCodigo());
        }
    }

    public void eliminarProducto(Producto producto)
    {
        if (listaProductos.remove(producto))
        {
            guardarProductos();
            System.out.println("Se elimino el producto -> " + producto.getCodigo());
        }

    }

    public void eliminarProducto(int id)
    {
        Producto producto = null;
        producto = existeProducto(id);

        if (producto!=null)
        {
            eliminarProducto(producto);
        }
    }

/*---------------------------------------------------------------------------*/

    private LinkedList<DetalleVenta> listarDetalleVentas()
    {
        texto = Archivo.leer("./datos/Detalle_Ventas.txt");

        st = new StringTokenizer(texto, ":\n");
        LinkedList<DetalleVenta> lista = new LinkedList<DetalleVenta>();

        try
        {
            while (st.hasMoreTokens())
            {
                DetalleVenta vt = new DetalleVenta();
                vt.setCodVenta(Integer.parseInt(st.nextToken()));
                vt.setCodCliente(Integer.parseInt(st.nextToken()));
                vt.setCodProducto(Integer.parseInt(st.nextToken()));
                vt.setCantidad(Integer.parseInt(st.nextToken()));
                vt.setTotalParcial(Integer.parseInt(st.nextToken()));

                vt.setFecha(vt.stringToDate(st.nextToken()));
                lista.add(vt);

            }
        } 
        catch (Exception e)
        {
            e.printStackTrace();
        }
        return lista;
    }

    public LinkedList<DetalleVenta> getListaDetalle_Ventas()
    {
        return listaDetalle_Ventas;
    }

    public void guardarDetalle_Ventas()
    {
        texto = "";
        for (DetalleVenta vt: listaDetalle_Ventas)
        {
            texto += vt.toString() + "\n";
        }
        Archivo.escribir("./datos/Detalle_Ventas.txt", texto);
    }

    public boolean existeVenta(int id)
    {
        for (DetalleVenta vt: listaDetalle_Ventas)
        {
            if (vt.getCodVenta() == id)
                return true;
        }
        return false;
    }

    public boolean existeDetalle_Venta(DetalleVenta detalle)
    {
        for (DetalleVenta vt: listaDetalle_Ventas)
        {
            if (vt.getCodVenta() == detalle.getCodVenta() && vt.getCodCliente() == detalle.getCodCliente()
                && vt.getCodProducto() == detalle.getCodProducto() )
                return true;
        }
        return false;
    }

    public DetalleVenta existeDetalle_Venta(int codVenta, int codCliente, int codProducto)
    {
        for (DetalleVenta vt: listaDetalle_Ventas)
        {
            if (vt.getCodVenta() == codVenta && vt.getCodCliente() == codCliente &&
                vt.getCodProducto() == codProducto)
                return vt;
        }
        return null;
    }

    public LinkedList<DetalleVenta> getDetalle_Venta(int id)
    {
        LinkedList<DetalleVenta> aux = new LinkedList<DetalleVenta>();

        for (DetalleVenta vt: listaDetalle_Ventas)
        {
            if (vt.getCodVenta() == id)
                aux.add(vt);
        }
        return aux;
    }

    public int getCantidadDetalle_Ventas()
    {
        return listaDetalle_Ventas.size();
    }

    public int getLastIDVenta()
    {
        if (!listaDetalle_Ventas.isEmpty())
            return listaDetalle_Ventas.getLast().getCodVenta();
        else
            return 0;
    }

    public void adicionarDetalle_Venta(DetalleVenta detalle)
    {
        if (!existeDetalle_Venta(detalle))
        {
            Producto pr = existeProducto(detalle.getCodProducto());
            pr.setStock(pr.getStock() - detalle.getCantidad());
            actualizarProducto(pr);

            listaDetalle_Ventas.add(detalle);
  
            guardarDetalle_Ventas();
            System.out.println("Se adiciono el detalle de ventas -> " + detalle.toString() );
        }
    }

    public void actualizarDetalle_Venta(DetalleVenta detalle)
    {
        LinkedList<DetalleVenta> aux = new LinkedList<DetalleVenta>();

        if (existeDetalle_Venta(detalle))
        {
            for(DetalleVenta det: listaDetalle_Ventas)
            {
                if (det.getCodVenta() == detalle.getCodVenta() && det.getCodCliente() == detalle.getCodCliente()
                    && det.getCodProducto() == detalle.getCodProducto())
                        aux.add(detalle);
                else
                    aux.add(det);
            }

            listaDetalle_Ventas = aux;
            guardarDetalle_Ventas();
            System.out.println("Se actualizo el detalle -> " + detalle.toString());
        }
    }

    public void eliminarDetalle_Venta(DetalleVenta detalle)
    {
        if (listaDetalle_Ventas.remove(detalle))
        {
            guardarDetalle_Ventas();
            System.out.println("Se elimino el detalle -> " + detalle.toString());
        }
    }

  /*  public void eliminarVenta(int id)
    {
        for(DetalleVenta det: listaDetalle_Ventas)
        {
            if (det.getCodVenta() == id)
                listaDetalle_Ventas.remove(det);
        }
        guardarDetalle_Ventas();
    }*/

}
